// 群聊管理模块
import roleManager from './role.js';
import groupService from '@/utils/groupService.js';
import { MessageStorage, MessageType } from './message-storage.js';

// 群聊消息前缀
const GROUP_CHAT_HISTORY_PREFIX = 'GRP_';
const DEFAULT_ROLES_KEY = 'DEFAULT_GROUP_CHAT_ROLES';
const MAX_GROUP_HISTORY_LENGTH = 100; // 群聊消息最大长度

class GroupChatManager {
  constructor() {
    this.groupChats = [];
    this.defaultRoleIds = this._loadDefaultRoles();
    // 标记是否已从线上获取过群聊
    this.hasInitializedOnlineGroups = false;
    // 创建消息存储实例，使用前缀模式
    this.messageStorage = new MessageStorage(GROUP_CHAT_HISTORY_PREFIX, MAX_GROUP_HISTORY_LENGTH);
  }

  // 从存储加载默认角色ID列表
  _loadDefaultRoles() {
    try {
      const defaultRoles = uni.getStorageSync(DEFAULT_ROLES_KEY);
      if (defaultRoles) {
        const roleIds = JSON.parse(defaultRoles);
        
        // 验证角色是否存在
        const validRoleIds = roleIds.filter(roleId => {
          const role = roleManager.getRoleByIdSync(roleId);
          return !!role;
        });
        
        // 如果有角色已被删除，更新默认角色列表
        if (validRoleIds.length < roleIds.length) {
          console.log(`[群聊管理] 检测到默认角色中有已删除角色，更新默认角色列表: ${roleIds.length} -> ${validRoleIds.length}`);
          this._saveDefaultRoles(validRoleIds);
          return validRoleIds;
        }
        
        return roleIds;
      }
      
      // 如果没有保存过默认角色，尝试获取前两个成人角色作为默认角色
      const adultRoles = roleManager.getAdultRolesSync();
      
      if (adultRoles && adultRoles.length >= 2) {
        const defaultRoleIds = [adultRoles[0].id, adultRoles[1].id];
        this._saveDefaultRoles(defaultRoleIds);
        return defaultRoleIds;
      }
      
      return [];
    } catch (e) {
      console.error('[群聊管理] 加载默认角色失败:', e);
      return [];
    }
  }

  // 保存默认角色ID列表到存储
  _saveDefaultRoles(roleIds) {
    try {
      uni.setStorageSync(DEFAULT_ROLES_KEY, JSON.stringify(roleIds));
      this.defaultRoleIds = roleIds;
    } catch (e) {
      console.error('[群聊管理] 保存默认角色失败:', e);
    }
  }

  // 获取默认角色ID列表
  getDefaultRoleIds() {
    return this.defaultRoleIds;
  }

  // 设置默认角色ID列表
  setDefaultRoleIds(roleIds) {
    if (!Array.isArray(roleIds)) {
      console.error('[群聊管理] 设置默认角色失败: 角色ID列表必须是数组');
      return false;
    }
    
    this._saveDefaultRoles(roleIds);
    return true;
  }

  // 从线上获取群聊
  async initializeOnlineGroups() {
    // 如果已经初始化过，则不再重复获取
    if (this.hasInitializedOnlineGroups) {
      console.log('[群聊管理] 已经初始化过线上群聊，跳过');
      return;
    }
    
    try {
      console.log('[群聊管理] 开始从线上获取群聊');
      
      // 获取所有高级角色（变量a）
      const adultRoles = roleManager.getAdultRolesSync();
      const adultRolesMap = new Map();
      adultRoles.forEach(role => {
        adultRolesMap.set(String(role.id), role);
      });
      
      // 获取线上群聊
      const result = await groupService.getAllGroups();
      
      if (result.errCode === 0) {
        const onlineGroups = result.data || [];
        console.log(`[群聊管理] 获取线上群聊成功，数量: ${onlineGroups.length}`);
        
        // 处理线上群聊
        const processedOnlineGroups = onlineGroups.map(group => {
          // 使用服务器返回的id字段
          const id = group.id || group._id;
          
          // 获取群聊的角色ID列表并转换为字符串类型
          const allMemberIds = (group.members || []).map(id => String(id));
          
          // 过滤出存在于高级角色中的角色ID
          const validMemberIds = allMemberIds.filter(roleId => adultRolesMap.has(roleId));
          
          // 如果有角色被过滤，记录日志
          if (validMemberIds.length < allMemberIds.length) {
            console.warn(`[群聊管理] 群聊 ${id} 中过滤了 ${allMemberIds.length - validMemberIds.length} 个无效角色ID`);
            
            // 更新群聊成员列表
            groupService.updateGroup({
              id: id,
              members: validMemberIds
            }).catch(error => {
              console.error(`[群聊管理] 更新群聊 ${id} 成员列表失败:`, error);
            });
          }
          
          return {
            ...group,
            id: id,
            // 使用有效的成员ID列表
            roleIds: validMemberIds,
            _id: undefined
          };
        });
        
        // 更新群聊列表
        this.groupChats = processedOnlineGroups;
        
        console.log(`[群聊管理] 获取到的群聊数量: ${processedOnlineGroups.length}`);
        
        // 标记为已初始化
        this.hasInitializedOnlineGroups = true;
      } else {
        console.error(`[群聊管理] 获取线上群聊失败: ${result.errMsg}`);
      }
    } catch (error) {
      console.error('[群聊管理] 初始化线上群聊异常:', error);
    }
  }

  // 获取所有群聊
  async getAllGroups() {
    // 确保已从线上初始化过群聊
    await this.initializeOnlineGroups();
    
    return {
      errCode: 0,
      errMsg: '获取群聊列表成功',
      data: this.groupChats
    };
  }

  // 同步方法获取所有群聊（不保证最新）
  getAllGroupsSync() {
    return this.groupChats;
  }

  // 根据ID获取群聊
  async getGroupById(groupId) {
    try {
      // 获取所有高级角色（变量a）
      const adultRoles = roleManager.getAdultRolesSync();
      const adultRolesMap = new Map();
      adultRoles.forEach(role => {
        adultRolesMap.set(String(role.id), role);
      });
      
      const result = await groupService.getGroupById(groupId);
      
      if (result.errCode === 0 && result.data) {
        // 获取群聊的角色ID列表并转换为字符串类型
        const allMemberIds = (result.data.members || []).map(id => String(id));
        
        // 过滤出存在于高级角色中的角色ID
        const validMemberIds = allMemberIds.filter(roleId => adultRolesMap.has(roleId));
        
        // 如果有角色被过滤，更新服务器的群聊成员列表
        if (validMemberIds.length < allMemberIds.length) {
          console.warn(`[群聊管理] 群聊 ${groupId} 中过滤了 ${allMemberIds.length - validMemberIds.length} 个无效角色ID`);
          
          // 异步更新群聊成员列表
          groupService.updateGroup({
            id: groupId,
            members: validMemberIds
          }).catch(error => {
            console.error(`[群聊管理] 更新群聊 ${groupId} 成员列表失败:`, error);
          });
        }
        
        // 处理群聊数据
        const updatedGroup = {
          ...result.data,
          id: result.data.id || result.data._id,
          // 使用有效的成员ID列表
          roleIds: validMemberIds,
          _id: undefined
        };
        
        // 更新本地缓存
        const index = this.groupChats.findIndex(chat => chat.id === groupId);
        if (index !== -1) {
          this.groupChats[index] = updatedGroup;
        } else {
          this.groupChats.push(updatedGroup);
        }
        
        return updatedGroup;
      }
    } catch (error) {
      console.error(`[群聊管理] 获取线上群聊失败: ${error.message}`);
    }
    
    // 如果从线上获取失败，返回本地缓存的数据
    return this.groupChats.find(chat => chat.id === groupId);
  }

  // 同步方法获取群聊（不保证最新）
  getGroupChatById(groupId) {
    return this.groupChats.find(chat => chat.id === groupId);
  }

  // 创建新群聊
  async createGroupChat(roleIds = null) {
    // 检查用户是否登录
    const userInfo = uni.getStorageSync('userInfo');
    const isLoggedIn = !!(userInfo && userInfo.token);
    
    if (!isLoggedIn) {
      console.error('[群聊管理] 创建群聊失败: 用户未登录');
      return null;
    }
    
    // 使用默认角色ID列表（如果没有提供）
    const chatRoleIds = roleIds || [...this.defaultRoleIds];
    
    try {
      // 格式化群聊信息，确保角色ID是字符串类型
      const groupData = {
        // 让服务端生成群聊名字，与服务端格式保持一致
        members: chatRoleIds.map(id => String(id))
      };
      
      console.log('[群聊管理] 创建群聊，发送数据:', JSON.stringify(groupData));
      
      const result = await groupService.createGroup(groupData);
      
      if (result.errCode === 0 && result.data) {
        // 创建群聊对象
        const groupChat = {
          id: result.data.id,
          roleIds: result.data.members.map(id => String(id)), // 使用服务器返回的成员列表
          name: result.data.name,
          createTime: result.data.createTime
        };
        
        // 添加到群聊列表
        this.groupChats.push(groupChat);
        
        console.log('[群聊管理] 已创建线上群聊:', groupChat.id, '角色数量:', groupChat.roleIds.length);
        
        return groupChat;
      } else {
        console.error(`[群聊管理] 创建线上群聊失败: ${result.errMsg}`);
        return null;
      }
    } catch (error) {
      console.error('[群聊管理] 创建线上群聊异常:', error);
      return null;
    }
  }

  // 更新群聊信息
  async updateGroupChat(groupId, updates) {
    const index = this.groupChats.findIndex(chat => chat.id === groupId);
    if (index === -1) return null;
    
    try {
      // 格式化更新数据
      const updateData = {
        id: groupId,
        name: updates.name || this.groupChats[index].name, // 确保总是有name值
        members: updates.roleIds || this.groupChats[index].roleIds
      };
      
      const result = await groupService.updateGroup(updateData);
      
      if (result.errCode !== 0) {
        console.error(`[群聊管理] 更新线上群聊失败: ${result.errMsg}`);
        return null;
      }
      
      // 更新本地群聊信息
      this.groupChats[index] = {
        ...this.groupChats[index],
        ...updates
      };
      
      return this.groupChats[index];
    } catch (error) {
      console.error('[群聊管理] 更新线上群聊异常:', error);
      return null;
    }
  }

  // 删除群聊
  async deleteGroupChat(groupId) {
    const index = this.groupChats.findIndex(chat => chat.id === groupId);
    if (index === -1) return false;
    
    try {
      const result = await groupService.deleteGroup(groupId);
      
      if (result.errCode !== 0) {
        console.error(`[群聊管理] 删除线上群聊失败: ${result.errMsg}`);
        return false;
      }
      
      // 从列表中删除
      this.groupChats.splice(index, 1);
      
      // 删除对应的聊天记录
      await this.clearGroupChatHistory(groupId);
      
      return true;
    } catch (error) {
      console.error('[群聊管理] 删除线上群聊异常:', error);
      return false;
    }
  }

  // 添加角色到群聊
  async addRoleToGroupChat(groupId, roleId) {
    const groupChat = this.getGroupChatById(groupId);
    if (!groupChat) return false;
    
    // 确保roleId是字符串类型
    const roleIdStr = String(roleId);
    
    // 检查角色是否已在群聊中
    if (groupChat.roleIds.some(id => String(id) === roleIdStr)) {
      console.log('[群聊管理] 角色已在群聊中:', roleIdStr);
      return true;
    }
    
    try {
      // 获取最新的群聊信息
      const updatedGroup = await this.getGroupById(groupId);
      if (!updatedGroup) {
        console.error('[群聊管理] 获取群聊信息失败');
        return false;
      }
      
      // 检查角色是否已在最新的群聊成员列表中
      if (updatedGroup.roleIds.some(id => String(id) === roleIdStr)) {
        console.log('[群聊管理] 角色在服务器端已在群聊中');
        // 更新本地缓存
        groupChat.roleIds = updatedGroup.roleIds;
        return true;
      }
      
      const result = await groupService.addMember(groupId, roleIdStr);
      
      if (result.errCode !== 0) {
        console.error(`[群聊管理] 在线上群聊中添加角色失败: ${result.errMsg}`);
        return false;
      }
      
      // 添加角色ID到群聊
      groupChat.roleIds.push(roleIdStr);
      
      console.log('[群聊管理] 已添加角色到群聊:', roleIdStr, '群聊:', groupId);
      return true;
    } catch (error) {
      console.error('[群聊管理] 在线上群聊中添加角色异常:', error);
      return false;
    }
  }

  // 从群聊中移除角色
  async removeRoleFromGroupChat(groupId, roleId) {
    const groupChat = this.getGroupChatById(groupId);
    if (!groupChat) return false;
    
    // 确保roleId是字符串类型
    const roleIdStr = String(roleId);
    
    // 检查角色是否在群聊中
    const index = groupChat.roleIds.findIndex(id => String(id) === roleIdStr);
    if (index === -1) {
      console.log('[群聊管理] 角色不在群聊中:', roleId);
      return false;
    }
    
    try {
      // 获取最新的群聊信息
      const updatedGroup = await this.getGroupById(groupId);
      if (!updatedGroup) {
        console.error('[群聊管理] 获取群聊信息失败');
        return false;
      }
      
      // 再次检查角色是否在最新的群聊成员列表中
      if (!updatedGroup.roleIds.some(id => String(id) === roleIdStr)) {
        console.error('[群聊管理] 角色在服务器端已不在群聊中');
        // 更新本地缓存
        groupChat.roleIds = updatedGroup.roleIds;
        return false;
      }
      
      const result = await groupService.removeMember(groupId, roleIdStr);
      
      if (result.errCode !== 0) {
        console.error(`[群聊管理] 从线上群聊中移除角色失败: ${result.errMsg}`);
        return false;
      }
      
      // 移除角色ID
      groupChat.roleIds.splice(index, 1);
      
      console.log('[群聊管理] 已从群聊中移除角色:', roleIdStr, '群聊:', groupId);
      return true;
    } catch (error) {
      console.error('[群聊管理] 从线上群聊中移除角色异常:', error);
      return false;
    }
  }

  // 获取群聊中的角色ID列表
  getGroupChatRoleIds(groupId) {
    const groupChat = this.getGroupChatById(groupId);
    return groupChat ? groupChat.roleIds : [];
  }

  // 设置群聊角色ID列表
  async setGroupChatRoleIds(groupId, roleIds) {
    if (!groupId) {
      console.error('[群聊管理] 设置群聊角色失败: 群聊ID为空');
      return false;
    }
    
    if (!Array.isArray(roleIds)) {
      console.error('[群聊管理] 设置群聊角色失败: 角色ID列表不是数组');
      return false;
    }
    
    // 确保所有角色ID都是字符串类型
    const stringRoleIds = roleIds.map(id => String(id));
    
    console.log(`[群聊管理] 设置群聊 ${groupId} 的角色ID列表，数量: ${stringRoleIds.length}`);
    
    try {
      // 获取所有高级角色
      const adultRoles = roleManager.getAdultRolesSync();
      const adultRolesMap = new Map();
      adultRoles.forEach(role => {
        adultRolesMap.set(String(role.id), role);
      });
      
      // 只保留在高级角色列表中存在的角色ID
      const validRoleIds = stringRoleIds.filter(roleId => {
        const exists = adultRolesMap.has(roleId);
        if (!exists) {
          console.warn(`[群聊管理] 角色ID ${roleId} 不在高级角色列表中，已被过滤`);
        }
        return exists;
      });
      
      // 如果有被过滤的角色，记录日志
      if (validRoleIds.length < stringRoleIds.length) {
        console.warn(`[群聊管理] 过滤了 ${stringRoleIds.length - validRoleIds.length} 个无效角色ID`);
        console.log(`[群聊管理] 最终使用的有效角色ID:`, validRoleIds);
      }
      
      // 使用群聊服务更新角色ID列表
      const result = await groupService.updateGroup({
        id: groupId,
        members: validRoleIds
      });
      
      if (result && result.errCode === 0) {
        // 在本地缓存中更新群聊信息
        const index = this.groupChats.findIndex(group => group.id === groupId);
        if (index !== -1) {
          // 更新本地缓存中的角色ID列表
          this.groupChats[index].roleIds = validRoleIds;
          console.log(`[群聊管理] 群聊 ${groupId} 角色ID列表更新成功`);
        } else {
          console.warn(`[群聊管理] 群聊 ${groupId} 不在本地缓存中，无法更新本地缓存`);
        }
        
        return true;
      } else {
        console.error(`[群聊管理] 更新群聊 ${groupId} 角色ID列表失败: ${result ? result.errMsg : '未知错误'}`);
        return false;
      }
    } catch (error) {
      console.error(`[群聊管理] 设置群聊 ${groupId} 角色ID列表异常:`, error);
      return false;
    }
  }

  // 获取群聊历史消息
  async getGroupChatHistory(groupId) {
    return await this.messageStorage.getMessages(groupId);
  }

  // 保存群聊历史消息
  async saveGroupChatHistory(groupId, messages) {
    return await this.messageStorage.saveMessages(groupId, messages);
  }

  // 清除群聊历史记录
  async clearGroupChatHistory(groupId) {
    return await this.messageStorage.clearMessages(groupId);
  }

  // 获取群聊中的所有角色信息
  getGroupChatRoles(groupId) {
    const roleIds = this.getGroupChatRoleIds(groupId);

    if (!roleIds || roleIds.length === 0) {
      console.log(`[群聊管理] 群聊 ${groupId} 没有设置角色`);
      return [];
    }
    
    console.log(`[群聊管理] 获取群聊 ${groupId} 的角色信息，角色ID数量: ${roleIds.length}`);
    
    // 获取所有高级角色（变量a）
    const adultRoles = roleManager.getAdultRolesSync();
    
    // 获取当前线上角色ID列表（变量b）
    const currentRoleIds = roleIds;
    
    // 创建一个映射，用于快速查找角色
    const adultRolesMap = new Map();
    adultRoles.forEach(role => {
      adultRolesMap.set(String(role.id), role);
    });
    
    // 确定有效角色ID列表（变量c = 变量a和变量b的并集，重叠部分）
    const validRoles = [];
    const validRoleIds = [];
    
    // 检查当前角色ID是否还存在于高级角色中
    for (const roleId of currentRoleIds) {
      const stringRoleId = String(roleId);
      const role = adultRolesMap.get(stringRoleId);
      
      if (role) {
        validRoles.push(role);
        validRoleIds.push(stringRoleId);
      } else {
        console.warn(`[群聊管理] 角色ID ${stringRoleId} 不在高级角色列表中，可能已被删除`);
      }
    }
    
    // 如果有效角色列表和当前角色列表不同，更新群聊成员
    if (validRoleIds.length !== currentRoleIds.length) {
      console.log(`[群聊管理] 检测到已删除角色，更新群聊角色列表: ${currentRoleIds.length} -> ${validRoleIds.length}`);
      this.setGroupChatRoleIds(groupId, validRoleIds);
    }
    
    console.log(`[群聊管理] 返回群聊 ${groupId} 的有效角色数量: ${validRoles.length}`);
    return validRoles;
  }

  // 获取可添加到群聊的角色列表
  getAvailableRolesForGroupChat(groupId) {
    // 获取当前群聊中的角色ID
    const currentRoleIds = this.getGroupChatRoleIds(groupId);
    
    // 获取所有成人角色
    const allAdultRoles = roleManager.getAdultRolesSync();
    
    // 确保所有角色ID都是字符串类型
    const stringCurrentRoleIds = currentRoleIds.map(id => String(id));
    
    // 过滤出未在群聊中的角色
    return allAdultRoles.filter(role => {
      // 确保角色ID是字符串类型进行比较
      const roleId = String(role.id);
      return !stringCurrentRoleIds.includes(roleId);
    });
  }

  // 更新群聊角色（一次性更新）
  async updateGroupChatRoles(groupId, roleIds) {
    if (!groupId || !Array.isArray(roleIds)) {
      console.error('[群聊管理] 更新群聊角色失败: 参数无效');
      return false;
    }
    
    try {
      // 确保角色ID都是字符串类型
      const stringRoleIds = roleIds.map(id => String(id));
      
      // 更新群聊信息
      const result = await groupService.updateGroup({
        id: groupId,
        members: stringRoleIds
      });
      
      if (result && result.errCode === 0) {
        // 更新成功，更新本地缓存
        const index = this.groupChats.findIndex(chat => chat.id === groupId);
        if (index !== -1) {
          this.groupChats[index].roleIds = stringRoleIds;
          console.log(`[群聊管理] 群聊角色更新成功，ID: ${groupId}, 角色数量: ${stringRoleIds.length}`);
        } else {
          console.warn(`[群聊管理] 群聊角色更新成功，但本地缓存中未找到该群聊: ${groupId}`);
        }
        
        return true;
      } else {
        console.error(`[群聊管理] 更新群聊角色失败: ${result ? result.errMsg : '未知错误'}`);
        return false;
      }
    } catch (error) {
      console.error('[群聊管理] 更新群聊角色异常:', error);
      return false;
    }
  }
}

// 创建单例实例
const groupChatManager = new GroupChatManager();

// 导出单例和消息类型
export { MessageType };
export default groupChatManager; 